Enhance support for switch statements - #99

src/types/checker/environment.ts (1)

44-46: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

Consider adding the Enum base members that the code generator depends on.

The global Enum entry is an empty ClassType. It declares no ordinal(), name(), or compareTo(...) members. src/compiler/code-generator.ts emits INVOKEVIRTUAL java/lang/Enum.ordinal()I for enum switch selectors, so the runtime contract assumes those members exist. A source program that calls selector.ordinal() will fail type checking with CannotFindSymbolError, even though the compiler can emit the call.

Adding at least ordinal() returning int and name() returning String keeps the type environment consistent with the emitted bytecode.

Using ClassType rather than EnumClass for the base is correct here, because checkSwitchExpression must not accept the abstract base as a selector.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/types/checker/environment.ts` around lines 44 - 46, The global Enum entry
in the type environment is missing members required by type checking and
generated bytecode. Update the Enum ClassType declaration to add ordinal()
returning int and name() returning String, preserving it as ClassType so
checkSwitchExpression does not accept the abstract base as a selector.

src/compiler/code-generator.ts (1)

1379-1398: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Narrow the try block and correct the maxStack adjustment.

Two points on this normalization block.

The try at line 1383 wraps both the queryClass lookup and the bytecode emission. queryClass throws SymbolNotFoundError for an unresolved name, which is the case this code intends to tolerate. The current form also swallows any failure from indexMethodrefInfo. Wrap only the lookup, or check for the class before emitting.

Line 1393 sets maxStack to exprStackSize + 1. ordinal() pops the objectref and pushes an int, so the net stack change is zero and the peak stays at exprStackSize. Over-reserving is safe for the verifier, but the extra slot is unnecessary and the expression suggests a growth that does not occur.

♻️ Proposed refactor

     let _resultType = resultType
     if (_resultType && _resultType.startsWith('L') && _resultType !== 'Ljava/lang/String;') {
       const clean = _resultType.replace(/^L|;$/g, '')
+      let classInfo
       try {
-        const classInfo = cg.symbolTable.queryClass(clean)
-        if (classInfo.accessFlags & ACCESS_FLAGS.ACC_ENUM) {
-          // call java.lang.Enum.ordinal() (returns int)
-          cg.code.push(
-            OPCODE.INVOKEVIRTUAL,
-            0,
-            cg.constantPoolManager.indexMethodrefInfo('java/lang/Enum', 'ordinal', '()I')
-          )
-          _resultType = 'I'
-          maxStack = Math.max(maxStack, exprStackSize + 1)
-        }
-      } catch (e) {
-        // ignore: not a known class
+        classInfo = cg.symbolTable.queryClass(clean)
+      } catch {
+        classInfo = undefined // not a known class
+      }
+      if (classInfo && classInfo.accessFlags & ACCESS_FLAGS.ACC_ENUM) {
+        // call java.lang.Enum.ordinal() (returns int)
+        cg.code.push(
+          OPCODE.INVOKEVIRTUAL,
+          0,
+          cg.constantPoolManager.indexMethodrefInfo('java/lang/Enum', 'ordinal', '()I')
+        )
+        _resultType = 'I'
       }
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/compiler/code-generator.ts` around lines 1379 - 1398, Narrow the
try/catch in the enum normalization block around cg.symbolTable.queryClass so
only unresolved-class lookup failures are ignored; let indexMethodrefInfo and
bytecode emission errors propagate. When emitting Enum.ordinal(), update
maxStack using exprStackSize rather than exprStackSize + 1, since the invocation
has zero net stack growth.

src/types/checker/index.ts (2)

585-666: 📐 Maintainability & Code Quality | 🔵 Trivial | 🏗️ Heavy lift

Extract the shared class-body checking logic instead of duplicating the NormalClassDeclaration branch.

Lines 585-666 duplicate lines 487-583 almost verbatim. Only the declaration list source differs: node.classBody.classBodyDeclarations becomes bodyDecls. The frame setup, the constructor index arithmetic, the field initializer check, the overload index computation, and the counter updates are identical.

Two copies must now stay in sync. A fix applied to one branch will silently miss the other.

Extract a helper that takes classType, the declaration list, and the frame, then call it from both branches.

The as any casts at lines 622, 639, 642, and 656 are also avoidable. The surrounding switch (bodyDeclaration.kind) already narrows the node type, and the equivalent class branch needs no casts. If bodyDecls is typed as any[], type the enum body declaration list properly so the narrowing works.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/types/checker/index.ts` around lines 585 - 666, Extract the duplicated
class-body checking flow from the NormalClassDeclaration and EnumDeclaration
branches into a shared helper accepting classType, declaration list, and frame,
preserving constructor indexing, field initializer checks, method overload
resolution, and declaration counters. Invoke the helper from both branches, and
type the enum declaration list so switch narrowing removes the unnecessary as
any casts in the enum handling.

---

727-740: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Use the typed caseConstants field for checker switch labels.

SwitchLabel declares only caseConstants, and the checker AST extractor emits that field. Remove singular-property probing and as any casts. Narrow to the caseConstants variant and iterate over switchLabel.caseConstants. The separate src/ast/astExtractor/statement-extractor.ts model is not used by this checker.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/types/checker/index.ts` around lines 727 - 740, Update the switch-label
handling in the type-checker branch to use only the typed
SwitchLabel.caseConstants field. Remove the singular caseConstant probing and
all any casts, narrow to the caseConstants variant, and iterate directly over
switchLabel.caseConstants while preserving the existing type-checking and error
behavior.

src/types/checker/prechecks.ts (1)

128-159: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Enum constant and method registration look correct.

Registering each enum constant as a field whose type is the enum class matches Java semantics. The constructor and method handling mirrors the NormalClassDeclaration path.

One consistency note: this branch returns on the first error, while the NormalClassDeclaration path accumulates errors and reports them together. Accumulating here would report all enum body problems in one pass.

Also applies to: 173-185

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/types/checker/prechecks.ts` around lines 128 - 159, The EnumDeclaration
processing should accumulate errors from enum constants, constructors, and
methods instead of returning on the first failure. Update the enum registration
loops and createMethodLocal handling to collect TypeCheckerError instances,
continue processing remaining declarations, and return the combined errors after
the enum body has been processed, matching the NormalClassDeclaration path.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

This PR extends switch-statement support by constraining the allowed selector types (String, integral primitives excluding long, and enums) and introduces enum parsing/type-checking/compilation paths to enable enum-based switching end-to-end.

Changes:

• Added an enum type representation (EnumClass) and updated switch selector validation to permit String and enum selectors.
• Implemented enum handling across the type-checker prechecks/body checks and expanded switch-case constant handling for differing AST shapes.
• Added compiler grammar + code generation support for enums (including enum switch lowering) and introduced compiler/type-checker tests for the new behavior.

Suppressed comments (2)

src/types/checker/prechecks.ts:71

• Frame.setType() returns null | TypeCheckerError (not Error), so this duplicate-type check will never trigger for enums; the method will incorrectly succeed even when the enum type name is already defined.

      if (error instanceof Error) return newResult(null, [new DuplicateClassError(node.location)])

src/compiler/compiler.ts:208

• When bodyMembers.length !== 0 you skip generating the synthetic enum constructor/ordinal method, but <clinit> still unconditionally invokes <init>(Ljava/lang/String;I)V for each constant (see addEnumStaticInitializer). This will produce invalid bytecode for enums with explicit constructors/fields, and enum constant argument lists are currently ignored (e.g. EARTH(1)).

    if (bodyMembers.length === 0) {
      this.addEnumConstructor()
      this.addEnumOrdinalMethod()
    } else {
      this.handleClassBody(bodyMembers)
    }

• Files reviewed: 18/18 changed files
• Comments generated: 4
• Review effort level: Lite